home *** CD-ROM | disk | FTP | other *** search
/ MacFormat UK 86 / MF_UK_86_1.iso / Shareware Plus / Utilities / Reaper 132 / Source Code / Reaper Window.c < prev    next >
Encoding:
C/C++ Source or Header  |  1999-11-11  |  21.6 KB  |  1,027 lines  |  [TEXT/CWIE]
  1. // AKUA Protos OneFile
  2. /////////////////////////////
  3. //
  4. //    Includes Beg
  5. //
  6. #define        STANDALONER            TRUE
  7.  
  8. #include    "yLibCfg.h"
  9.  
  10. #include    "Reaper.h"
  11.  
  12. #ifndef        _yDragH
  13. #include    "yDrag.h"
  14. #endif    //    _yDragH
  15.  
  16. #ifndef        _yDrawH
  17. #include    "yDraw.h"
  18. #endif    //    _yDrawH
  19.  
  20. #ifndef        _yGlobalH
  21. #include    "yGlobal.h"
  22. #endif    //    _yGlobalH
  23.  
  24. #ifndef        _yMemoryH
  25. #include    "yMemory.h"
  26. #endif    //    _yMemoryH
  27.  
  28. #ifndef        _yStringH
  29. #include    "yString.h"
  30. #endif    //    _yStringH
  31.  
  32.  
  33. #include    <Devices.h>
  34. //
  35. //    Includes End
  36. //
  37. /////////////////////////////
  38.  
  39. /*****************************************************************************************************************\
  40.  
  41.     File:        cdev.c
  42.  
  43.     Version:    1.10
  44.  
  45.     Contains:    'OAGT' Object Agent for OdoClock 
  46.                     
  47.     Written by:    Gregory Mathias Lemperle-Kerr
  48.  
  49.     Copyright:    ©1992-1996 worldwide by AKUA Interactive Media, Inc. All rights reserved
  50.  
  51.     Usage:        This file contains the code for an 'OAGT' that dynamically connects to
  52.                  the 'cdev' to handle the window object. Messages from the Finder are translated
  53.                  to standard window agent messages and passed on to the OAGT who may pass them
  54.                  on to panel object agents.
  55.  
  56.     To Do:
  57.  
  58.     History:
  59.     110    GOD    19.03.1997    Added speech
  60.  
  61.     100    GOD    15.05.1996    Start
  62.  
  63. \*****************************************************************************************************************/
  64.  
  65.  
  66. // AKUA Statics Beg
  67. oaVal main(oaObj windowObject);
  68. void waSmartTest(void);
  69. void waAppMenuAdd(ident id, StringPtr name, bool byName);
  70. void waAppMenuItemSet(short n, ident id, StringPtr name, bool byName);
  71. void waAppMenuUpdate(window w);
  72. void waAppIdxSet(window w, ident id, StringPtr name);
  73. int waAppIdxGet(window w);
  74. void waSettingsUpdate(window w);
  75. short waHeapToMenuVal(short heap);
  76. short waHeapMenuItemVal(short menuIdx);
  77. void waBitHit(window w, ident itemID, flag16 bit, appItem item);
  78. void wiMaxSet(window w, ident itemID, short val);
  79. void wiMaxSetI(wndObj itm, short val);
  80. void wiValSet(window w, ident itemID, short val);
  81. void wiValSetI(wndObj itm, short val);
  82. short wiValGet(window w, ident itemID);
  83. short wiValGetI(wndObj itm);
  84. void wiRedraw(window w, ident itemID);
  85. void wiRedrawI(drawPort dp, wndObj itm);
  86. void wiEnable(window w, ident itemID, bool onOff);
  87. void wiEnableI(drawPort dp, wndObj itm, bool onOff);
  88. void wiValUnset(wndObj item, bool onOff);
  89. bool wiValUnget(wndObj item);
  90. void wiTxtGetI(wndObj itm, StringPtr txt);
  91. void wiTxtSetI(wndObj itm, StringPtr txt);
  92. void wiTxtGet(window w, ident itemID, StringPtr txt);
  93. void wiTxtSet(window w, ident itemID, StringPtr txt);
  94. wndObj wiGet(window w, ident itemID);
  95. yError osErrorSet(yError err);
  96. void dpVariantChange(drawPort dp, byte newVariant);
  97. void dpVariantSet(drawPort dp, byte newVariant);
  98. byte dpVariantGet(drawPort dp);
  99. bool evUserCancel(void);
  100. KeyModFlag evModifiers(void);
  101. KeyModFlag evModConvert(flag16 sysMods);
  102. KeyModFlag evModsDown(void);
  103. void evKeysDown(StringPtr keys);
  104. bool evMods(KeyModFlag testThese);
  105. Handle rsGetOne(fileSpec file, ident classID);
  106. Handle rsGetOne(fileSpec file, ident classID, RsrcNumber resNum);
  107. oaVal rsGet1All(oAgent agt, oaObj obj, Handle * whereInObj, bool load);
  108. Handle rsGetX(fila family);
  109. Handle rsGet(ident resKind, ident resId);
  110. Handle rsGet1X(fila family);
  111. Handle rsGet1(ident myType, ident myIdent);
  112. Handle rsGet1Idx(ResType resClass, int wholeIdx);
  113. Handle rsGet1Num(ResType resClass, RsrcNumber resNum);
  114. Handle rsGet1NumDetach(ResType resClass, RsrcNumber resNum);
  115. Handle rsGetNum(ResType resClass, RsrcNumber resNum);
  116. Handle rsGetNumDetach(ResType resClass, RsrcNumber resNum);
  117. Handle rsGetIdx(ResType resClass, int wholeIdx);
  118. Handle rsGetIdxDetach(ResType resClass, int wholeIdx);
  119. Handle rsGet1IdxDetach(ResType resClass, int wholeIdx);
  120. Handle rsGet1Named(ident resKind, StringPtr name);
  121. Handle rsGetNamed(ident resKind, StringPtr name);
  122. Handle rsGetNamedDetach(ident resKind, StringPtr name);
  123. Handle rsGet1Random(ident resKind);
  124. Handle mmHdlNewClr(lwrd s);
  125. void mmBlkClr(void * p, long s);
  126. void mmBlkCpyCode(const void * p, void * q, long s);
  127. void mmBlkCpy(const void * p, void * q, long s);
  128. void mmBlkSwap(void * p, void * q, long s);
  129. yError mmHdlCpy(const void * srcHdl, void * dstHdl);
  130. yError mmHdlCpyAt(const void * srcHdl, register void * dstHdl, long where);
  131. yError mmHdlDup(const void * srcHdl, void * dstHdlPtr);
  132. yError mmHdlDupTmp(const void * srcHdl, register void * dstHdlPtr);
  133. void * mmHdlExtendLine(void * hdl, StringPtr line);
  134. void * mmHdlExtendClr(void * hdl, long cnt);
  135. StringPtr mmHdlExtend(void * hdl, long cnt);
  136. yError mmHdlSizeSetX(void * hdl, long newSize);
  137. StringPtr mmHdlExpandAt(void * hdl, void * where, long howManyBytes);
  138. yError mmHdlExpandX(void * hdl, void * where, long howManyBytes);
  139. yError mmHdlExpand(void * hdl, long where, long howManyBytes);
  140. HdlState mmHdlResizeBeg(const void * dataHdl);
  141. void mmHdlResizeEnd(const void * dataHdl, HdlState saveState);
  142. HdlState mmHdlWorkBegX(const void * dataHdl, bool longTerm);
  143. HdlState mmHdlWorkBeg(const void * dataHdl);
  144. void mmHdlWorkEnd(const void * dataHdl, HdlState saveState);
  145. bool mmHdlWorkStatic(const void * hdl);
  146. Ptr mmPtrNew(lwrd s);
  147. Ptr mmPtrNewClr(lwrd s);
  148. void msWaitBeg(void);
  149. void msWaitEnd(void);
  150. void msRotate(void);
  151. bool osProcessExists(long procID);
  152. bool osProcessTrapInstall(short * installCnt, ProcessNum *** installed, word trapWord, SysProc trapAdr, SysProc * jumpAdr);
  153. ident osProcessCurrentId(void);
  154. ProcessNum osProcessId(ProcessNum procNum, ident * creator, ProcessSN * psn);
  155. bool osProcessInFront(void);
  156. yError osProcessToFront(void);
  157. bool osProcessWasFront(ProcessSN * currentPSN);
  158. yError osProcessFind(ident appID, register ProcessSN * appSN);
  159. yError osProcessInfo(ProcessSN * appSN, ProcessInfoRec * appInfo);
  160. yError osProcessSetFront(ident appID);
  161. yError osProcessSetFrontSN(ProcessSN * psn);
  162. yError osProcessLaunch(ident appID, fileSpec specIfNoID, ProcessSN * appSN, AppParametersPtr parms, bool front, bool quit);
  163. yError osProcessSpec(ProcessNum procNum, fileSpec appSpec);
  164. yError osProcessFindOnDisk(ident appID, fileSpec appSpec);
  165. yError osProcessFindOnVol(ident appID, VolRef vRefNum, fileSpec appSpec);
  166. ProcessNum osProcessSpecToNum(fileSpec fs);
  167. void osProcessFirst(ProcessSN * appSN, ProcessInfoRec * appInfo, StringPtr name, fileSpec fs);
  168. yError osProcessNext(ProcessSN * appSN, ProcessInfoRec * appInfo, StringPtr name, ident creator, bool bgAlso);
  169. bool osProcessWaitForUser(int waitSecsBeforeForce);
  170. // AKUA Statics End
  171.  
  172.  
  173.  
  174. enum PanelItemIDs
  175.  {
  176.     // Actions
  177.     ipiImport                    = 'Get…',
  178.     ipiRemove                    = 'Rmv!',
  179.     ipiTest                        = 'Test',
  180.     // Check Boxes
  181.     ipiOnlyIfROM                = 'ROM+',
  182.     ipiByName                    = 'Nam+',
  183.     ipiExpand                    = 'Exp+',
  184.     ipiSmartHeap                = 'SmH+',
  185.     ipiLimitHeap                = 'Lim+',
  186.     ipiRun68K                    = '68K+',
  187.     ipiFixFCB                    = 'FCB+',
  188.     // Radio Buttons
  189.     // Menus
  190.     ipiApplication                = 'App ',
  191.     ipiHeap                        = 'Heap',
  192.     // Text
  193.     ipiCreator                    = 'AppC',
  194.     ipiInfo                        = 'Info',
  195.     ipiVersion                    = 'Vers',
  196.     ipiAkua                        = 'AKUA',
  197.     // Pictures
  198.     ipiTitle                    = 'TITL',
  199.     ipiBoxT                        = 'BoxT',
  200.     ipiBoxL                        = 'BoxL',
  201.     ipiBoxB                        = 'BoxB',
  202.     ipiBoxR                        = 'BoxR',
  203.     ipiDivider                    = 'BoxD'
  204.  };
  205.  
  206.  
  207. enum PanelItemVals
  208.  {
  209.     kivHeapNoChange            = 1,
  210.     kivHeapDivider,
  211.     kivHeapLowest,
  212.  
  213.     kivAppRWM                = 1,    // Default - all other apps
  214.     kivAppROM,                        // all ROM apps
  215.     kivAppZero,                        // Divider
  216.     kivAppOne,                        // First "real" app
  217.  
  218.     // Menu IDs
  219.     kmiHeap                    = -4064,
  220.     kmiApplication            = -4047
  221.  };
  222.  
  223.  
  224. enum AlertNums
  225.  {
  226.     kalTest                    = -4059,
  227.     kalTestWarn                = -4058,
  228.     kalTestGood                = -4057,
  229.     kalTestBad                = -4056
  230.  };
  231.  
  232.  
  233. // Assuming idx==1 means first app…
  234. #define    mcPrefItem(pref, idx)    ((pref)->item + ((idx) - kivAppOne))
  235. #define    mcMenuItem(idx)            ((idx) + kivAppZero)
  236.  
  237.  
  238.  
  239. MonkeyFlag        theMonkey        = 0;
  240. FileRef            swaHomeRef        = 0;
  241. BADAPP            thePrefs        = NULL;
  242. MenuHandle        swaAppMenu        = NULL;
  243. MenuHandle        swaHeapMenu        = NULL;
  244. bool            swaPrefsChanged    = FALSE;
  245.  
  246.  
  247. oaVal main(oaObj windowObject)
  248.  {
  249.     EnterCodeRsrc();
  250.  
  251.     window            w = (window)windowObject;
  252.     oaVal            retVal = noErr;
  253.  
  254.     switch(mcWdMsg(w))
  255.      {
  256.       case kwmIdle:
  257.         if (swaPrefsChanged && thePrefs)
  258.          {
  259.             swaPrefsChanged = FALSE;
  260.             
  261.             if (rsFlush(thePrefs))
  262.                 SysBeep(11);
  263.  
  264.             // Update extension if running…
  265.             long    gest;
  266.  
  267.             if (!Gestalt(igsReaper, &gest))
  268.              {
  269.                 reaperGlo    gat = (reaperGlo)gest;
  270.  
  271.                 if (gat->prefs && ((*gat->prefs)->version == (*thePrefs)->version))
  272.                     mmHdlCpy(thePrefs, gat->prefs);
  273.                 else
  274.                  {
  275.                     Str63        iText;
  276.                     wiTxtGet(w, ipiAkua, iText);
  277.                     wiTxtSet(w, ipiAkua, "\pOLDER REAPER IS INSTALLED.");
  278.                     Delay(30, (lwrd *)&gest);
  279.                     wiTxtSet(w, ipiAkua, iText);
  280.                  }
  281.              }
  282.             else
  283.              {
  284.                 Str63        iText;
  285.                 wiTxtGet(w, ipiAkua, iText);
  286.                 wiTxtSet(w, ipiAkua, "\pTHE REAPER IS NOT INSTALLED.");
  287.                 Delay(30, (lwrd *)&gest);
  288.                 wiTxtSet(w, ipiAkua, iText);
  289.              }
  290.          }
  291.       break;
  292.  
  293.  
  294.       case kwmCtrlUp:
  295.         if (BADAPP prefs = thePrefs)
  296.          {
  297.             msWaitBeg();
  298.  
  299.             switch (mcWdHit(w))
  300.              {
  301.               case ipiApplication:
  302.                 waSettingsUpdate(w);
  303.               break;
  304.  
  305.               case ipiRemove:
  306.                 goto remove;
  307.  
  308.               case ipiTest:
  309.                 waSmartTest();
  310.               break;
  311.  
  312.               default:
  313.                {
  314.                 HdlState    saveState    = mmHdlWorkBeg(prefs);
  315.                 badApp        pref        = *prefs;
  316.                 int            appIdx        = waAppIdxGet(w);
  317.                 appItem        item        = (appIdx > 0) ? (pref->item + appIdx - 1) : NULL;
  318.                 short      *    reapP        = item ? &item->reap :
  319.                                             appIdx ? &pref->reapRWM : &pref->reapROM;
  320.  
  321.                 flag16        bit = 0;
  322.  
  323.                 switch (mcWdHit(w))
  324.                  {
  325.                   // Radios
  326.                   // Flags
  327.                   case ipiOnlyIfROM:        bit = bbaOnlyIfROM;        break;
  328.                   case ipiByName:            bit = bbaByName;        break;
  329.                   case ipiExpand:            bit = bbaExpand;        break;
  330.                   case ipiSmartHeap:        bit = bbaSmartHeap;        break;
  331.                   case ipiLimitHeap:        bit = bbaLimitHeap;        break;
  332.                   case ipiRun68K:            bit = bbaRun68K;        break;
  333.                   case ipiFixFCB:            bit = bbaFixFCB;        break;
  334.  
  335.                   // Menus
  336.                   case ipiHeap:
  337.                     *reapP = waHeapMenuItemVal(mcWdHitVal(w));
  338.                     swaPrefsChanged        = TRUE;
  339.                   break;
  340.  
  341.                   default:
  342.                     SysBeep(11);
  343.                   break;
  344.                  }
  345.  
  346.                 if (bit && item)
  347.                     waBitHit(w, mcWdHit(w), bit, item);
  348.  
  349.                 mmHdlWorkEnd(prefs, saveState);
  350.                }
  351.              }
  352.  
  353.             msWaitEnd();
  354.          }
  355.       break;
  356.  
  357.  
  358.       case kwmUpdate:
  359.         if (!mcFlagTst(theMonkey, bEvMonkeyLives))
  360.          {
  361.             mcFlagSet(theMonkey, bEvMonkeyLives);
  362.             // Initial drawing? Enable/Disable controls etc.
  363.             waSettingsUpdate(w);
  364.          }
  365.       break;
  366.  
  367.  
  368.       case kwmClear:
  369. remove:    if (int appIdx = waAppIdxGet(w)) if (appIdx > 0) if (BADAPP prefs = thePrefs)
  370.             if (!mmHdlExpandX(prefs, &(*prefs)->item[--appIdx], -sizeof(AppItem)))
  371.          {
  372.             DeleteMenuItem(swaAppMenu, appIdx + kivAppOne);
  373.  
  374.             if (appIdx == -- (*prefs)->cnt)    // was last item
  375.                 wiValSet(w, ipiApplication, appIdx ? (appIdx + kivAppZero) : 1);
  376.  
  377.             stSlutSet(prefs, mcPrefSlutOffset(*prefs), appIdx + 1, NULL, FALSE);
  378.  
  379.             waAppMenuUpdate(w);
  380.             waSettingsUpdate(w);
  381.             swaPrefsChanged = TRUE;
  382.          }
  383.       break;
  384.  
  385.  
  386.       case kwmDragInq:
  387.       break;
  388.  
  389.  
  390.       case kwmDragIn:    // Current resFile may not be our home, so post the change
  391.        {
  392.         dragInfoItem    item = mcDdDragInItem(w);
  393.  
  394.         switch(item->flavor)
  395.          {
  396.           case flavorTypeHFS:
  397.             if (item->hfs.fileCreator == igsReaper)
  398.              {
  399.                 if (Handle prefs = rsGetOne(&item->hfs.fileSpec, ircPreferences))
  400.                  {
  401.                     if (**(word **)prefs >= kvrReaperMinCompat)
  402.                      {
  403.                         mmHdlCpy(prefs, thePrefs);
  404.  
  405.                         waAppMenuUpdate(w);
  406.                         wiValSet(w,    ipiApplication, kivAppRWM);
  407.                         waSettingsUpdate(w);
  408.  
  409.                         swaPrefsChanged = TRUE;
  410.                      }
  411.  
  412.                     mmHdlDel(prefs);
  413.  
  414.                     if (!swaPrefsChanged)
  415.                         goto beep;
  416.                  }
  417.                 else
  418.                     goto beep;
  419.              }
  420.             else
  421.              {
  422.                 msWaitBeg();
  423.  
  424.                 // Add to prefs or get its settings…
  425.                 if (Handle crap = rsGetOne(&item->hfs.fileSpec, ircSizeOfHeap))
  426.                     mmHdlDel(crap);
  427.                 else if (osProcessFindOnDisk(item->hfs.fileCreator, &item->hfs.fileSpec))
  428.                  {
  429.                     SysBeep(21);
  430.                     goto noAdd;
  431.                  }
  432.  
  433.                 waAppIdxSet(w, item->hfs.fileCreator, item->hfs.fileSpec.name);
  434.  
  435. noAdd:            msWaitEnd();
  436.              }
  437.           break;
  438.  
  439.           default:
  440. beep:        SysBeep(11);
  441.           break;
  442.          }
  443.        }
  444.       break;
  445.  
  446.  
  447.       case kwmInit:
  448.         msWaitBeg();
  449.  
  450.         swaHomeRef = CurResFile();
  451.  
  452.         if (!(thePrefs = (BADAPP)rsGet('PREF', igsReaper)))
  453.             SysBeep(11);
  454.  
  455.         swaHeapMenu    = GetMenu(kmiHeap);
  456.  
  457.         if (swaAppMenu = GetMenu(kmiApplication))
  458.             waAppMenuUpdate(w);
  459.  
  460.         SetWTitle(mcWdPort(w), "\pThe Reaper by AKUA");
  461.  
  462.         msWaitEnd();
  463.       break;
  464.  
  465.  
  466.       case kwmQuit:
  467.       break;
  468.      }
  469.  
  470.     LeaveCodeRsrc();
  471.     return    retVal;
  472.  }
  473.  
  474.  
  475.  
  476. void waSmartTest(void)
  477.  {
  478.     Size    tf        = TempFreeMem();
  479.     NoteAlert(kalTestGood, NULL);
  480.     return;
  481.  
  482.     long    ram;
  483.     Handle    crap;
  484.     yError    err;
  485.  
  486.     Gestalt(gestaltLogicalRAMSize, &ram);
  487.  
  488.     THz        tmpZone = HandleZone(crap = TempNewHandle(9, &err));
  489.  
  490.     mmHdlDel(crap);
  491.  
  492.     if (((Ptr)tmpZone > osROMBase)
  493.          || ((long)tmpZone > ram)
  494.          || ((long)tmpZone < 0)
  495.          || (tmpZone != osTwitchZone) )
  496.         StopAlert(kalTestWarn, NULL);
  497.     else
  498.      {
  499.         long    diff    = tf - tmpZone->zcbFree;
  500.  
  501.         if (diff < 0)
  502.             diff = -diff;
  503.  
  504.         if ((tmpZone->zcbFree > ram) || (tmpZone->zcbFree < 0) || (diff > 0x10000L))
  505.             CautionAlert(kalTestBad, NULL);
  506.         else
  507.             NoteAlert(kalTestGood, NULL);
  508.      }
  509.  }
  510.  
  511.  
  512.  
  513. void waAppMenuAdd(ident id, StringPtr name, bool byName)
  514.  {
  515.     AppendMenu(swaAppMenu, "\pAkua");
  516.     waAppMenuItemSet(CountMenuItems(swaAppMenu), id, name, byName);
  517.  }
  518.  
  519.  
  520.  
  521. void waAppMenuItemSet(short n, ident id, StringPtr name, bool byName)
  522.  {
  523.     Str63        itemName;
  524.  
  525.     stPtoP(name, itemName);
  526.  
  527.     itemName[++*itemName]= ' ';
  528.     itemName[++*itemName]= byName ? '(' : '[';
  529.     utIdToText(id, itemName + *itemName + 1);
  530.     itemName[0] += sizeof(id);
  531.     itemName[++*itemName]= byName ? ')' : ']';
  532.  
  533.     SetMenuItemText(swaAppMenu, n, itemName);
  534.  }
  535.  
  536.  
  537.  
  538. void waAppMenuUpdate(window w)
  539.  {
  540.     if (BADAPP prefs = thePrefs)
  541.      {
  542.         HdlState    saveState    = mmHdlWorkBeg(prefs);
  543.         badApp        pref        = *prefs;
  544.         int            cnt            = pref->cnt;
  545.         int            cmax        = cnt;
  546.         appItem        item        = pref->item;
  547.         StringPtr    name        = mcSlutString(mcPrefSlutX(item, cnt));
  548.  
  549.         while(short n = CountMenuItems(swaAppMenu))
  550.             DeleteMenuItem(swaAppMenu, n);
  551.  
  552.         AppendMenu(swaAppMenu, "\pDefaults;Read-Only Application;(-");
  553.  
  554.         for( ; cnt; cnt--, item ++, name += *name + 1)
  555.             waAppMenuAdd(item->creator, name, mcObjBool(item, bbaByName));
  556.  
  557.         wiMaxSet(w, ipiApplication, cmax);
  558.  
  559.         mmHdlWorkEnd(prefs, saveState);
  560.      }
  561.  }
  562.  
  563.  
  564.  
  565.  
  566. void waAppIdxSet(window w, ident id, StringPtr name)
  567.  {
  568.     msWaitBeg();
  569.  
  570.     if (BADAPP prefs = thePrefs)
  571.      {
  572.         int            appIdx;
  573.         bool        matchedName;
  574.  
  575.         appItem        item = rpFindApp(prefs, id, name, TRUE, &appIdx, &matchedName);
  576.  
  577.         if (!item || !matchedName)
  578.          {
  579.             if (mmHdlExpand(prefs, mcPrefSlutOffset(*prefs), sizeof(AppItem)))
  580.              {
  581.                 SysBeep(11);
  582.                 appIdx = 0;
  583.              }
  584.             else
  585.              {
  586.                 badApp    pref    = *prefs;
  587.  
  588.                  item = pref->item + pref->cnt;
  589.  
  590.                 appIdx = ++ pref->cnt;        // Added a new item
  591.  
  592.                  item->creator    = id;
  593.                 item->reap        = -25;    // 25% default?
  594.                 item->flags        = 0;
  595.  
  596.                 // Add name to list
  597.                 BreakStr(name);
  598.                 stSlutSet(prefs, mcPrefSlutOffset(*prefs), appIdx, name, FALSE);
  599.  
  600.                 waAppMenuAdd(id, name, FALSE);
  601.  
  602.                 swaPrefsChanged        = TRUE;
  603.              }
  604.          }
  605.  
  606.         wiValSet(w,    ipiApplication, appIdx + kivAppZero);
  607.  
  608.         waSettingsUpdate(w);
  609.      }
  610.  
  611.     msWaitEnd();
  612.  }
  613.  
  614.  
  615.  
  616.  
  617. int waAppIdxGet(window w)
  618.  {
  619.     int        appIdx =    wiValGet(w, ipiApplication);
  620.  
  621.     if (!appIdx)
  622.         wiValSet(w, ipiApplication, appIdx = 1);        
  623.  
  624.     // Cut off divider - first app is 1, 0 is default
  625.     // 1 to -1, 2 to 0 for defaults
  626.     return    appIdx -= (appIdx > kivAppZero) ? kivAppZero : (kivAppZero - 1);
  627.  }
  628.  
  629.  
  630.  
  631.  
  632. void waSettingsUpdate(window w)
  633.  {
  634.     msWaitBeg();
  635.  
  636.     if (BADAPP prefs = thePrefs)
  637.      {
  638.         // Get current settings
  639.         short        reap;
  640.  
  641.         int            appIdx        = waAppIdxGet(w);
  642.         badApp        pref        = *prefs;
  643.  
  644.         wiEnable(w, ipiFixFCB,        appIdx > 0);
  645.         wiEnable(w, ipiRun68K,        appIdx > 0);
  646.         wiEnable(w, ipiLimitHeap,    appIdx > 0);
  647.         wiEnable(w, ipiSmartHeap,    appIdx > 0);
  648.         wiEnable(w, ipiExpand,        appIdx > 0);
  649.         wiEnable(w, ipiByName,        appIdx > 0);
  650.         wiEnable(w, ipiOnlyIfROM,    appIdx > 0);
  651.         wiEnable(w, ipiRemove,        appIdx > 0);
  652.  
  653.         if (appIdx > 0)
  654.          {
  655.             appItem    item = pref->item + appIdx - 1;
  656.  
  657.             // Check Boxes
  658.             wiValSet(w, ipiFixFCB,        mcObjBool(item, bbaFixFCB)        );
  659.             wiValSet(w, ipiRun68K,        mcObjBool(item, bbaRun68K)        );
  660.             wiValSet(w, ipiLimitHeap,    mcObjBool(item, bbaLimitHeap)    );
  661.             wiValSet(w, ipiSmartHeap,    mcObjBool(item, bbaSmartHeap)    );
  662.             wiValSet(w, ipiExpand,        mcObjBool(item, bbaExpand)        );
  663.             wiValSet(w, ipiByName,        mcObjBool(item, bbaByName)        );
  664.             wiValSet(w, ipiOnlyIfROM,    mcObjBool(item, bbaOnlyIfROM)    );
  665.  
  666.             reap = item->reap;
  667.          }
  668.         else
  669.          {
  670.             wiValSet(w, ipiFixFCB,        FALSE    );
  671.             wiValSet(w, ipiRun68K,        FALSE    );
  672.             wiValSet(w, ipiLimitHeap,    FALSE    );
  673.             wiValSet(w, ipiSmartHeap,    FALSE    );
  674.             wiValSet(w, ipiExpand,        FALSE    );
  675.             wiValSet(w, ipiByName,        FALSE    );
  676.             wiValSet(w, ipiOnlyIfROM,    FALSE    );
  677.             reap = appIdx ? pref->reapRWM : pref->reapROM;
  678.          }
  679.  
  680.         // Heap Value
  681.         wiValSet(w,    ipiHeap, waHeapToMenuVal(reap));
  682.      }
  683.  
  684.     msWaitEnd();
  685.  }
  686.  
  687.  
  688.  
  689.  
  690. short waHeapToMenuVal(short heap)
  691.  {
  692.     if (!heap)
  693.         return    kivHeapNoChange;
  694.  
  695.     short        bestItem    = kivHeapLowest;
  696.     short        best        = 0;
  697.     int            itemCnt        = CountMenuItems(swaHeapMenu);
  698.  
  699.     for(int i = kivHeapLowest; (i <= itemCnt); i++)
  700.      {
  701.         if (short mval = waHeapMenuItemVal(i))
  702.          {
  703.             // %age?
  704.             if ((heap < 0) && (mval < 0))
  705.              {
  706.                 if ((mval >= heap) && (mval < best))
  707.                  {
  708.                     best        = mval;
  709.                     bestItem    = i;
  710.                  }
  711.              }
  712.             else if ((heap > 0) && (mval > 0))
  713.              {
  714.                 if ((mval <= heap) && (mval > best))
  715.                  {
  716.                     best        = mval;
  717.                     bestItem    = i;
  718.                  }
  719.              }
  720.          }
  721.      }
  722.  
  723.     return    bestItem;
  724.  }
  725.  
  726.  
  727.  
  728. short waHeapMenuItemVal(short menuIdx)
  729.  {
  730.     Str63        iText;
  731.  
  732.     GetMenuItemText(swaHeapMenu, menuIdx, iText);
  733.  
  734.     // Divider?
  735.     if (!iText[0] || (iText[1] == '-'))
  736.         return    0;
  737.  
  738.     StringPtr    valTxt    = iText;
  739.     int            valLen    = *valTxt++;
  740.     long        val        = stParseValLong(&valTxt, &valLen);    // Get number
  741.  
  742.     switch (*++valTxt)
  743.      {
  744.       case '%':        val = -val;        break;
  745.  
  746.       case 'k':
  747.       case 'K':        val >>= 4;        break;
  748.  
  749.       case 'm':
  750.       case 'M':        val <<= 6;        break;
  751.      }
  752.  
  753.     return    val;
  754.  }
  755.  
  756.  
  757.  
  758.  
  759. void waBitHit(window w, ident itemID, flag16 bit, appItem item)
  760.  {
  761.     bool    onOff    = !wiValGet(w, itemID);
  762.  
  763.     wiValSet(w, itemID, onOff);
  764.     mcObjTog(item, bit);
  765.  
  766.     if (itemID == ipiByName)
  767.      {
  768.         int    appIdx = waAppIdxGet(w);
  769.  
  770.         if (appIdx > 0)
  771.          {
  772.             Str63        name;
  773.             GetMenuItemText(swaAppMenu, appIdx + kivAppZero, name);
  774.             stTransliterate(name + 1, *name, onOff ? "\p[" : "\p(", onOff ? "\p(" : "\p[");
  775.             stTransliterate(name + 1, *name, onOff ? "\p]" : "\p)", onOff ? "\p)" : "\p]");
  776.             SetMenuItemText(swaAppMenu, appIdx + kivAppZero, name);
  777.             wiRedraw(w, ipiApplication);
  778.          }
  779.      }
  780.  
  781.     swaPrefsChanged        = TRUE;
  782.  }
  783.  
  784.  
  785.  
  786.  
  787. void wiMaxSet(window w, ident itemID, short val)
  788.  {
  789.     if (wndObj itm = wiGet(w, itemID))
  790.         wiMaxSetI(itm, val);
  791.  }
  792.  
  793.  
  794.  
  795. void wiMaxSetI(wndObj itm, short val)
  796.  {
  797.     if (mcWoIsCtl(itm))
  798.      {
  799.         if (val > (*mcWoCtlHdl(itm))->contrlMax)
  800.             SetControlMaximum(mcWoCtlHdl(itm), val);
  801.  
  802.         InvalRect(&itm->bounds);    // Silly System 8 pop-ups don't react
  803.      }
  804.  }
  805.  
  806.  
  807.  
  808. void wiValSet(window w, ident itemID, short val)
  809.  {
  810.     if (wndObj itm = wiGet(w, itemID))
  811.         wiValSetI(itm, val);
  812.  }
  813.  
  814.  
  815.  
  816. void wiValSetI(wndObj itm, short val)
  817.  {
  818.     if (mcWoIsCtl(itm))
  819.      {
  820.         if (val > (*mcWoCtlHdl(itm))->contrlMax)
  821.             SetControlMaximum(mcWoCtlHdl(itm), val);
  822.  
  823.         InvalRect(&itm->bounds);    // Silly System 8 pop-ups don't react
  824.         SetControlValue(mcWoCtlHdl(itm), val);
  825.      }
  826.     else if (mcWoHasTxt(itm))
  827.      {
  828.         Str15        tempest;
  829.  
  830.         stLongToStr(val, tempest);
  831.         wiTxtSetI(itm, tempest);
  832.      }
  833.  }
  834.  
  835.  
  836.  
  837. short wiValGet(window w, ident itemID)
  838.  {
  839.     if (wndObj itm = wiGet(w, itemID))
  840.         return    wiValGetI(itm);
  841.  
  842.     return 0;
  843.  }
  844.  
  845.  
  846.  
  847. short wiValGetI(wndObj itm)
  848.  {
  849.     if (mcWoIsCtl(itm))
  850.         return GetControlValue(mcWoCtlHdl(itm));
  851.     else if (mcWoHasTxt(itm))
  852.      {
  853.         Str31        tempest;
  854.  
  855.         wiTxtGetI(itm, tempest);
  856.         return stValLong(tempest);
  857.      }
  858.  
  859.     return    0;
  860.  }
  861.  
  862.  
  863.  
  864. void wiRedraw(window w, ident itemID)
  865.  {
  866.     if (wndObj itm = wiGet(w, itemID))
  867.         wiRedrawI(mcWdDrawPort(w), itm);
  868.  }
  869.  
  870.  
  871.  
  872. void wiRedrawI(drawPort dp, wndObj itm)
  873.  {
  874.     InvalRect(&itm->bounds);    // Silly System 8 pop-ups don't react
  875.  }
  876.  
  877.  
  878.  
  879. void wiEnable(window w, ident itemID, bool onOff)
  880.  {
  881.     if (wndObj itm = wiGet(w, itemID))
  882.         wiEnableI(mcWdDrawPort(w), itm, onOff);
  883.  }
  884.  
  885.  
  886.  
  887. void wiEnableI(drawPort dp, wndObj itm, bool onOff)
  888.  {
  889.     // Not already in the requested state?
  890.     if (onOff == mcFlagTstBool(itm->kind, itemDisable))
  891.      {
  892.         if (mcWoIsCtl(itm))
  893.             HiliteControl(mcWoCtlHdl(itm), onOff ? 0 : 255);
  894.  
  895.         if (onOff)
  896.             mcFlagClr(itm->kind, itemDisable);
  897.         else
  898.             mcFlagSet(itm->kind, itemDisable);
  899.  
  900.         SetDialogItem(mcDpPort(dp), itm->idx, itm->kind, mcWoData(itm), &itm->bounds);
  901.      }
  902.  }
  903.  
  904.  
  905.  
  906. void wiValUnset(wndObj item, bool onOff)
  907.  {
  908.     Str63        iText;
  909.     StringPtr    title;
  910.  
  911.     wiTxtGetI(item, title = iText + 1);
  912.  
  913.     if (onOff && (iText[2] != (byte)'≈'))
  914.      {
  915.         iText[0] = *title + 1;
  916.         *title = '≈';
  917.         -- title;
  918.      }
  919.     else if (!onOff && (iText[2] == (byte)'≈'))
  920.      {
  921.         title[1] = *title - 1;
  922.         ++ title;
  923.      }
  924.     else
  925.         return;
  926.  
  927.     wiTxtSetI(item, title);
  928.  }
  929.  
  930.  
  931.  
  932. bool wiValUnget(wndObj item)
  933.  {
  934.     Str63        iText;
  935.  
  936.     wiTxtGetI(item, iText);
  937.  
  938.     return    (iText[1] == (byte)'≈');
  939.  }
  940.  
  941.  
  942.  
  943. void wiTxtGetI(wndObj itm, StringPtr txt)
  944.  {
  945.     txt[0] = 0;
  946.  
  947.     if (mcWoIsCtl(itm))
  948.         GetControlTitle(mcWoCtlHdl(itm), txt);
  949.     else if (mcWoHasTxt(itm))
  950.         GetDialogItemText(mcWoTxtHdl(itm), txt);
  951.  }
  952.  
  953.  
  954.  
  955. void wiTxtSetI(wndObj itm, StringPtr txt)
  956.  {
  957.     if (mcWoIsCtl(itm))
  958.         SetControlTitle(mcWoCtlHdl(itm), txt);
  959.     else if (mcWoHasTxt(itm))
  960.         SetDialogItemText(mcWoTxtHdl(itm), txt);
  961.  }
  962.  
  963.  
  964.  
  965. void wiTxtGet(window w, ident itemID, StringPtr txt)
  966.  {
  967.     if (wndObj itm = wiGet(w, itemID))
  968.         wiTxtGetI(itm, txt);
  969.  }
  970.  
  971.  
  972.  
  973. void wiTxtSet(window w, ident itemID, StringPtr txt)
  974.  {
  975.     if (wndObj itm = wiGet(w, itemID))
  976.         wiTxtSetI(itm, txt);
  977.  }
  978.  
  979.  
  980.  
  981. wndObj wiGet(window w, ident itemID)
  982.  {
  983.     if (PANEL tbl = mcWdTbl(w))
  984.      {
  985.         panel    t = *tbl;
  986.         wndObj    itm = t->itm;
  987.         int        cnt = t->cnt;
  988.  
  989.         while(cnt--)
  990.             if (itm->id == itemID)
  991.                 return(itm);
  992.             else
  993.                 ++ itm;
  994.      }
  995.  
  996.     return(NULL);
  997.  }
  998.  
  999.  
  1000.  
  1001.  
  1002. yError osErrorSet(yError err)
  1003.  {
  1004.     if (err)
  1005.         SysBeep(11);
  1006.     return(err);
  1007.  }
  1008.  
  1009.  
  1010.  
  1011.  
  1012.  
  1013. #define    Y_BAREBONES    TRUE
  1014.  
  1015. #include        "dpVariant.c"
  1016. #include        "evModifiers.c"
  1017. #include        "mmBlkClr.c"
  1018. #include        "mmHdlCpy.c"
  1019. #include        "mmHdlExpand.c"
  1020. #include        "mmHdlWork.c"
  1021. #include        "mmPtrNew.c"
  1022. #include        "msMinimal.c"
  1023. #include        "rsFileGetOne.c"
  1024. #include        "rsGet.c"
  1025. #include        "rsNew.c"
  1026. #include        "osProcess.c"
  1027.